home *** CD-ROM | disk | FTP | other *** search
/ Best Tools for JAVA / Best Tools for JAVA.iso / JAVA_ALL / HOTJAVA_ / HOTJAVA / CLASSSRC / JAVA / LANG / SYSTEM~1.JAV < prev    next >
Encoding:
Text File  |  1995-08-11  |  13.1 KB  |  370 lines
  1. /*
  2.  * @(#)System.java    1.22 95/05/10 Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.lang;
  21.  
  22. import java.io.*;
  23.  
  24. /**
  25.  * This class provides access to system functionality.
  26.  * One of the more useful things provided by this class
  27.  * are the standard i/o streams. They are used to do
  28.  * printing. For example:
  29.  * <pre>
  30.  *    System.out.println("Hello World!");
  31.  * </pre>
  32.  * @version     1.22, 10 May 1995
  33.  * @author    Arthur van Hoff
  34.  */
  35. public final
  36. class System {
  37.     /** Don't let anyone instantiate this class */
  38.     private System() {
  39.     }
  40.  
  41.     /**
  42.      * Standard input stream.
  43.      */
  44.     public static InputStream in =
  45.         new BufferedInputStream(new FileInputStream(0), 128);
  46.  
  47.     /**
  48.      * Standard output stream. This stream lets you print messages.
  49.      */
  50.     public static PrintStream out =
  51.         new PrintStream(new BufferedOutputStream(new FileOutputStream(1), 128), true);
  52.  
  53.     /**
  54.      * Standard error stream. This stream can be used to print error messages.
  55.      */
  56.     public static PrintStream err =
  57.         new PrintStream(new BufferedOutputStream(new FileOutputStream(2), 128), true);
  58.  
  59.     /**
  60.      * Returns the current time in milliseconds.
  61.      * This is obsolete, use currentTimeMillis instead.
  62.      * This method essentially always overflows.  It is only useful
  63.      * for measuring intervals less that 1<<21 seconds long.
  64.      * @return the time in milliseconds
  65.      * @see java.util.currentTimeMillis
  66.      */
  67.     public static native int nowMillis();
  68.  
  69.     /**
  70.      * Returns the current time in seconds GMT since the epoch (00:00:00
  71.      * UTC, January 1, 1970).
  72.      * This is obsolete, use currentTimeMillis instead.
  73.      * This method is susceptible to overflow.  It's got until 2038,
  74.      * but that's cutting things a bit fine: intermediate results in
  75.      * time calculations occasionally go awry.
  76.      * @see java.util.currentTimeMillis
  77.      */
  78.     public static native int currentTime();
  79.  
  80.     /**
  81.      * Returns the current time in milliseconds GMT since the epoch (00:00:00
  82.      * UTC, January 1, 1970).  It is a signed 64 bit integer, and so won't
  83.      * overflow until the year 292280995.
  84.      * @see java.util.Date
  85.      */
  86.     public static native long currentTimeMillis();
  87.  
  88.     /**
  89.      * Returns number of free bytes in system memory. This number
  90.      * is not always accurate.
  91.      * @return bytes free in system memory
  92.      */
  93.     public static native int freeMemory();
  94.  
  95.     /**
  96.      * Returns the total number of bytes in system memory. 
  97.      * @return bytes in system memory
  98.      */
  99.     public static native int totalMemory();
  100.  
  101.     /**
  102.      * Runs the garbage collector. Usually it is not necessary to call
  103.      * this method since there is an asynchronous garbage collector which
  104.      * runs whenever the system is idle.  The garbage collector also runs
  105.      * automatically when object allocation fails.
  106.      */
  107.     public static native void gc();
  108.  
  109.     /**
  110.      * Runs the finalization methods of any objects pending finalization.
  111.      * Usually it is not necessary to call this method since finalization
  112.      * methods will be called asynchronously by a finalization thread.
  113.      * However, because finalized resources are of the user's choosing,
  114.      * there is no built-in equivalent of the garbage collector running
  115.      * when the system runs out of memory.  With runFinalization(), users
  116.      * can build equivalent functionality into their resource allocators.
  117.      */
  118.     public static native void runFinalization();
  119.  
  120.     /**
  121.      * Copies an array of booleans.
  122.      * @param src        the source data
  123.      * @param srcpos    start position in the source data
  124.      * @param dest    the destination
  125.      * @param destpos    start position in the destination data
  126.      * @param length    length of the data to be copied
  127.      * @exception ArrayIndexOutOfBoundsException Copy would cause
  128.      *            access of data outside array bounds
  129.      */
  130.     public static void arraycopy(boolean src[], int srcpos, boolean dest[],
  131.                  int destpos, int length) {
  132.     boolean_arraycopy(src, srcpos, dest, destpos, length);
  133.     }
  134.  
  135.     /**
  136.      * Copies an array of bytes.
  137.      * @param src        the source data
  138.      * @param srcpos    start position in the source data
  139.      * @param dest    the destination
  140.      * @param destpos    start position in the destination data
  141.      * @param length    length of the data to be copied
  142.      * @exception ArrayIndexOutOfBoundsException Copy would cause
  143.      *            access of data outside array bounds
  144.      */
  145.     public static void arraycopy(byte src[], int srcpos, byte dest[],
  146.                  int destpos, int length) {
  147.     byte_arraycopy(src, srcpos, dest, destpos, length);
  148.     }
  149.  
  150.     /**
  151.      * Copies an array of characters.
  152.      * @param src        the source data
  153.      * @param srcpos    start position in the source data
  154.      * @param dest    the destination
  155.      * @param destpos    start position in the destination data
  156.      * @param length    length of the data to be copied
  157.      * @exception ArrayIndexOutOfBoundsException Copy would cause
  158.      *            access of data outside array bound
  159.      */
  160.     public static void arraycopy(char src[], int srcpos, char dest[],
  161.                  int destpos, int length) {
  162.     char_arraycopy(src, srcpos, dest, destpos, length);
  163.     }
  164.  
  165.     /**
  166.      * Copies an array of shorts.
  167.      * @param src        the source data
  168.      * @param srcpos    start position in the source data
  169.      * @param dest    the destination
  170.      * @param destpos    start position in the destination data
  171.      * @param length    length of the data to be copied
  172.      * @exception ArrayIndexOutOfBoundsException Copy would cause
  173.      *            access of data outside array bounds
  174.      */
  175.     public static void arraycopy(short src[], int srcpos, short dest[],
  176.                  int destpos, int length) {
  177.     short_arraycopy(src, srcpos, dest, destpos, length);
  178.     }
  179.  
  180.     /**
  181.      * Copies an array of integers.
  182.      * @param src        the source data
  183.      * @param srcpos    start position in the source data
  184.      * @param dest    the destination
  185.      * @param destpos    start position in the destination data
  186.      * @param length    length of the data to be copied
  187.      * @exception ArrayIndexOutOfBoundsException Copy would cause
  188.      *            access of data outside array bounds
  189.      */
  190.     public static void arraycopy(int src[], int srcpos, int dest[],
  191.                  int destpos, int length) {
  192.     int_arraycopy(src, srcpos, dest, destpos, length);
  193.     }
  194.  
  195.     /**
  196.      * Copies an array of longs.
  197.      * @param src        the source data
  198.      * @param srcpos    start position in the source data
  199.      * @param dest    the destination
  200.      * @param destpos    start position in the destination data
  201.      * @param length    length of the data to be copied
  202.      * @exception ArrayIndexOutOfBoundsException Copy would cause
  203.      *            access of data outside array bounds
  204.      */
  205.     public static void arraycopy(long src[], int srcpos, long dest[],
  206.                  int destpos, int length) {
  207.     long_arraycopy(src, srcpos, dest, destpos, length);
  208.     }
  209.  
  210.     /**
  211.      * Copies an array of floats.
  212.      * @param src        the source data
  213.      * @param srcpos    start position in the source data
  214.      * @param dest    the destination
  215.      * @param destpos    start position in the destination data
  216.      * @param length    length of the data to be copied
  217.      * @exception ArrayIndexOutOfBoundsException Copy would cause
  218.      *            access of data outside array bounds
  219.      */
  220.     public static void arraycopy(float src[], int srcpos, float dest[],
  221.                  int destpos, int length) {
  222.     float_arraycopy(src, srcpos, dest, destpos, length);
  223.     }
  224.  
  225.     /**
  226.      * Copies an array of doubles.
  227.      * @param src        the source data
  228.      * @param srcpos    start position in the source data
  229.      * @param dest    the destination
  230.      * @param destpos    start position in the destination data
  231.      * @param length    length of the data to be copied
  232.      * @exception ArrayIndexOutOfBoundsException Copy would cause
  233.      *            access of data outside array bounds
  234.      */
  235.     public static void arraycopy(double src[], int srcpos, double dest[],
  236.                  int destpos, int length) {
  237.     double_arraycopy(src, srcpos, dest, destpos, length);
  238.     }
  239.  
  240.     /**
  241.      * Copies an array of objects.
  242.      * @param src        the source data
  243.      * @param srcpos    start position in the source data
  244.      * @param dest    the destination
  245.      * @param destpos    start position in the destination data
  246.      * @param length    length of the data to be copied
  247.      * @exception ArrayIndexOutOfBoundsException copy would cause
  248.      *            access of data outside array bounds
  249.      * @exception IncompatibleTypeException Source and destination array types
  250.      *            do not match
  251.      */
  252.     public static void arraycopy(Object src[], int srcpos, Object dest[],
  253.                  int destpos, int length) {
  254.     object_arraycopy(src, srcpos, dest, destpos, length);
  255.     }
  256.  
  257.  
  258.     /* Yes we need these, the method names need to be different so that they
  259.      * can resolve to different symbols. This will be much easier once we
  260.      * have arrays as objects ;-)
  261.      */
  262.     private static native void boolean_arraycopy(boolean src[], int srcpos, boolean dest[],
  263.                          int destpos, int length);
  264.     private static native void byte_arraycopy(byte src[], int srcpos, byte dest[],
  265.                           int destpos, int length);
  266.     private static native void short_arraycopy(short src[], int srcpos, short dest[],
  267.                            int destpos, int length);
  268.     private static native void char_arraycopy(char src[], int srcpos, char dest[],
  269.                           int destpos, int length);
  270.     private static native void int_arraycopy(int src[], int srcpos, int dest[],
  271.                          int destpos, int length);
  272.     private static native void long_arraycopy(long src[], int srcpos, long dest[],
  273.                           int destpos, int length);
  274.     private static native void float_arraycopy(float src[], int srcpos, float dest[],
  275.                            int destpos, int length);
  276.     private static native void double_arraycopy(double src[], int srcpos, double dest[],
  277.                         int destpos, int length);
  278.     private static native void object_arraycopy(Object src[], int srcpos, Object dest[],
  279.                         int destpos, int length);
  280.     
  281.     /**
  282.      * Exits the interpreter with an exit code. This method does
  283.      * not return, use with caution.
  284.      * @param status    exit status, 0 is success
  285.      */
  286.     public static native void exit(int status);
  287.  
  288.     /* Obsolete...
  289.      * Helper function for exec and execout
  290.      */
  291.     private static native int exec0(String command, int DoRead);
  292.  
  293.     /**
  294.      * Executes a system command.  Returns a FileInputStream connected to the
  295.      * standard output of the command.  Fails if executed directly or
  296.      * indirectly by code loaded over the net.
  297.      */
  298.     public static InputStream execin(String command) {
  299.     return new BufferedInputStream(new FileInputStream(exec0(command, 1)))
  300. ;
  301.     }
  302.  
  303.     /**
  304.      * Executes a system command.  Returns a FileOutputStream connected to the
  305.      * standard input of the command.  Fails if executed directly or
  306.      * indirectly by code loaded over the net.
  307.      */
  308.     public static OutputStream execout(String command) {
  309.     return new BufferedOutputStream(new FileOutputStream(exec0(command, 0)));
  310.     }
  311.  
  312.     /**
  313.      * Executes a system command.  No redirection.
  314.      */
  315.     public static void exec(String command) {
  316.     exec0(command, -1);
  317.     }
  318.  
  319.     /**
  320.      * Gets an environment variable. An environment variable is a
  321.      * system dependent external variable that has a string value.
  322.      * @param var    the name of an environment variable.
  323.      * @return     the value of the variable, or null if the variable is
  324.      *        is not defined
  325.      */
  326.     public static native String getenv(String var);
  327.  
  328.     /**
  329.      * Get the current working directory.
  330.      * @return the system dependent name of the current directory.
  331.      */
  332.     public static native String getCWD();
  333.  
  334.     /**
  335.      * Get the name of the operating system.  In the rare event that
  336.      * you need to do something OS dependent, this is how you find
  337.      * out what you're running on.
  338.      * @return the system dependent name of current operating system.
  339.      */
  340.     public static native String getOSName();
  341.  
  342.     /**
  343.      * Enables/Disables tracing of instructions.
  344.      * @param on    start tracing if non-zero
  345.      */
  346.     public static native void traceInstructions(int on);
  347.  
  348.     /**
  349.      * Enables/Disables tracing of method calls.
  350.      * @param on    start tracing if non-zero
  351.      */
  352.     public static native void traceMethodCalls(int on);
  353.  
  354.     /**
  355.      * Enables/Disables profiling of method calls.
  356.      * @param on    start profiling if non-zero
  357.      */
  358.     public static native void profile(int on);
  359.  
  360.     /**
  361.      * Dumps profiling data.
  362.      */
  363.     public static native void dumpProfile();
  364.  
  365.     /**
  366.      * Dumps the state of all monitors.
  367.      */
  368.     public static native void dumpMon(Object obj);
  369. }
  370.